Skin Lesion Classification: ResNet18 (Experimentation)

This is one of the models that were implemented during the experimentation stage. This model was not implemented in the end due to problems with saving and loading it into the backend of the web application.

This algorithm uses ResNet18 neural network and is a modified version of a LeNet skin cancer detection algorithm originally by Soham Mazumder.

For this skin cancer detection algorithm HAM10000 ("Human Against Machine with 10000 training images") dataset was used which contains 10,015 dermatoscopic images.

The 7 classes of skin cancer lesions included in this dataset are:

1. Melanocytic nevi
2. Melanoma
3. Benign keratosis-like lesions
4. Basal cell carcinoma
5. Actinic keratoses
6. Vascular lesions
7. Dermatofibroma

Originally by Soham Mazumder

GitHub Link: https://github.com/IFL-CAMP/SLClassificationAnEducationalCode-MEC2019

import torch
from torch import nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

import numpy as np
import os
import shutil
import pandas as pd
import seaborn as sns
from glob import glob
import imageio
from PIL import Image
import glob
import math

from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, precision_recall_fscore_support
from sklearn.preprocessing import LabelEncoder, StandardScaler
import skimage
import scipy.ndimage
from scipy import misc
from scipy import stats

import matplotlib.pyplot as plt
import matplotlib
%matplotlib inline

# cuda
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
device

device(type='cpu')

Data Preperation & Import

# importing metadata and checking for its shape
data_dir =  "./data/HAM10000"

metadata = pd.read_csv(data_dir + '/HAM10000_metadata.csv')
print(metadata.shape)

# label encoding the seven classes for skin cancers
le = LabelEncoder()
le.fit(metadata['dx'])
LabelEncoder()
print("Classes:", list(le.classes_))
 
metadata['label'] = le.transform(metadata["dx"]) 
metadata.sample(10)

(10015, 8)
Classes: ['akiec', 'bcc', 'bkl', 'df', 'mel', 'nv', 'vasc']

	lesion_id	image_id	dx	dx_type	age	sex	localization	dataset	label
6645	HAM_0005544	ISIC_0027791	nv	follow_up	55.0	male	lower extremity	vidir_molemax	5
4868	HAM_0004057	ISIC_0026635	nv	follow_up	65.0	male	trunk	vidir_molemax	5
9658	HAM_0001956	ISIC_0030038	nv	consensus	30.0	female	back	vidir_modern	5
1737	HAM_0006802	ISIC_0032610	mel	histo	40.0	male	upper extremity	vidir_modern	4
1122	HAM_0004317	ISIC_0029039	df	histo	50.0	female	lower extremity	rosendahl	3
544	HAM_0002722	ISIC_0031289	bkl	histo	55.0	male	back	rosendahl	2
5858	HAM_0003297	ISIC_0024373	nv	follow_up	60.0	male	abdomen	vidir_molemax	5
3891	HAM_0002165	ISIC_0031172	nv	follow_up	55.0	male	lower extremity	vidir_molemax	5
446	HAM_0005558	ISIC_0030812	bkl	histo	85.0	male	face	rosendahl	2
6622	HAM_0001970	ISIC_0031136	nv	follow_up	50.0	male	trunk	vidir_molemax	5

Plotting the dataset distribution

fig = plt.figure(figsize=(40,25))

ax1 = fig.add_subplot(221)
metadata['dx'].value_counts().plot(kind='bar', ax=ax1)
ax1.set_ylabel('Count', size=50)
ax1.set_title('Cell Type', size = 50)

ax2 = fig.add_subplot(222)
metadata['sex'].value_counts().plot(kind='bar', ax=ax2)
ax2.set_ylabel('Count', size=50)
ax2.set_title('Sex', size=50);

ax3 = fig.add_subplot(223)
metadata['localization'].value_counts().plot(kind='bar')
ax3.set_ylabel('Count', size=50)
ax3.set_title('Localization', size=50)

ax4 = fig.add_subplot(224)
sample_age = metadata[pd.notnull(metadata['age'])]
sns.distplot(sample_age['age'], fit=stats.norm, color='red');
ax4.set_title('Age', size = 50)
ax4.set_xlabel('Year', size=50)

plt.tight_layout()
plt.show()

C:\Users\marty\anaconda3\envs\newEnv1\lib\site-packages\seaborn\distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).
  warnings.warn(msg, FutureWarning)

Sorting the dataset

Commented out function below takes the the HAM10000 dataset in its original form (data/HAM10000) and sorts all the images based on the type of skin cancer (data/HAM10K). It is commented out as it is already done and does not need to be run again.

# A path to the folder which has all the images:
data_dir = os.getcwd() + "/data/HAM10000/"

image_dir = data_dir + "Images/"

# A path to the folder where you want to store the rearranged images:
dest_dir = os.getcwd() + "/data/HAM10K"

# Read the metadata file:
metadata = pd.read_csv(data_dir + '/HAM10000_metadata.csv')
label = ['bkl', 'nv', 'df', 'mel', 'vasc', 'bcc', 'akiec']
label_images = []

# os.mkdir(dest_dir)
# for i in label:
#     os.mkdir(dest_dir + "/" + str(i) + "/")

# # Copy the images into new folder structure:
# for i in label:
#     sample = metadata[metadata['dx'] == i]['image_id']
#     label_images.extend(sample)
#     for id in label_images:
#         shutil.copyfile((image_dir + id +".jpg"), (dest_dir + "/" + i + "/"+id+".jpg"))
#     label_images=[]    

Visualizing the images

label = [ 'akiec', 'bcc','bkl','df','mel', 'nv',  'vasc']
label_images = []
classes = [ 'actinic keratoses', 'basal cell carcinoma', 'benign keratosis-like lesions', 
           'dermatofibroma','melanoma', 'melanocytic nevi', 'vascular lesions']

fig = plt.figure(figsize=(55, 55))
k = range(7)

for i in label:
    sample = metadata[metadata['dx'] == i]['image_id'][:5]
    label_images.extend(sample)
    
for position,ID in enumerate(label_images):
    labl = metadata[metadata['image_id'] == ID]['dx']
    im_sample = dest_dir + "/" + labl.values[0] + f'/{ID}.jpg'
    im_sample = imageio.imread(im_sample)

    plt.subplot(7,5,position+1)
    plt.imshow(im_sample)
    plt.axis('off')

    if position%5 == 0:
        title = int(position/5)
        plt.title(classes[title], loc='left', size=50, weight="bold")

plt.tight_layout()
plt.show()

label = [ 'akiec', 'bcc','bkl','df','mel', 'nv',  'vasc']

def estimate_weights_mfb(label):
    class_weights = np.zeros_like(label, dtype=np.float)
    counts = np.zeros_like(label)
    for i,l in enumerate(label):
        counts[i] = metadata[metadata['dx']==str(l)]['dx'].value_counts()[0]
    counts = counts.astype(np.float)
    #print(counts)
    median_freq = np.median(counts)
    #print(median_freq)
    #print(weights.shape)
    for i, label in enumerate(label):
        #print(label)
        class_weights[i] = median_freq / counts[i]
    return class_weights

classweight= estimate_weights_mfb(label)

for i in range(len(label)):
    print(label[i],":", classweight[i])

akiec : 1.5718654434250765
bcc : 1.0
bkl : 0.467697907188353
df : 4.469565217391304
mel : 0.4618149146451033
nv : 0.07665920954511558
vasc : 3.619718309859155

data_dir = "./data/HAM10K"

# Normalization values for pretrained resnet on Imagenet
norm_mean = (0.4914, 0.4822, 0.4465)
norm_std = (0.2023, 0.1994, 0.2010)

batch_size = 50
validation_batch_size = 10
test_batch_size = 10

# Computing the weights of individual classes and convert them to tensors
class_weights = estimate_weights_mfb(label)
class_weights = torch.FloatTensor(class_weights)

transform_train = transforms.Compose([
                    transforms.Resize((224,224)),
                    transforms.RandomHorizontalFlip(),
                    transforms.RandomRotation(degrees=60),
                    transforms.ToTensor(),
                    transforms.Normalize(norm_mean, norm_std),
                    ])

transform_test = transforms.Compose([
                    transforms.Resize((224,224)),
                    transforms.ToTensor(),
                    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
                    ])

Preparing the Model: Train, Test & Validation

Dataset is divided into 3 parts:

• Train: 80%
• Test: 20%
• Validation: 16%

The splitting is done class wise so that there's an equal representation of all classes in each subset of the data.

import torch as th

test_size = 0.2
val_size = 0.2
class Sampler(object):
    """Base class for all Samplers.
    """

    def __init__(self, data_source):
        pass

    def __iter__(self):
        raise NotImplementedError

    def __len__(self):
        raise NotImplementedError
        
class StratifiedSampler(Sampler):
    """Stratified Sampling
    Provides equal representation of target classes
    """
    def __init__(self, class_vector, test_size):
        """
        Arguments
        ---------
        class_vector : torch tensor
            a vector of class labels
        batch_size : integer
            batch_size
        """
        self.n_splits = 1
        self.class_vector = class_vector
        self.test_size = test_size

    def gen_sample_array(self):
        try:
            from sklearn.model_selection import StratifiedShuffleSplit
        except:
            print('Need scikit-learn for this functionality')
        import numpy as np
        
        s = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=self.test_size)
        X = th.randn(self.class_vector.size(0),2).numpy()
        y = self.class_vector.numpy()
        s.get_n_splits(X, y)

        train_index, test_index= next(s.split(X, y))
        return train_index, test_index

    def __iter__(self):
        return iter(self.gen_sample_array())

    def __len__(self):
        return len(self.class_vector)
    

dataset = torchvision.datasets.ImageFolder(root= data_dir)
data_label = [s[1] for s in dataset.samples]

ss = StratifiedSampler(torch.FloatTensor(data_label), test_size)
pre_train_indices, test_indices = ss.gen_sample_array()
# The "pre" is necessary to use array to identify train/ val indices with indices generated by second sampler

train_label = np.delete(data_label, test_indices, None)
ss = StratifiedSampler(torch.FloatTensor(train_label), test_size)
train_indices, val_indices = ss.gen_sample_array()
indices = {'train': pre_train_indices[train_indices],  # Indices of second sampler are used on pre_train_indices
           'val': pre_train_indices[val_indices],  # Indices of second sampler are used on pre_train_indices
           'test': test_indices
           }

train_indices = indices['train']
val_indices = indices['val']
test_indices = indices['test']
print("Train Data Size:", len(train_indices))
print("Test Data Size:", len(test_indices))
print("Validation Data Size:", len(val_indices))

Train Data Size: 6409
Test Data Size: 2003
Validation Data Size: 1603

Loading the dataset into memory

SubsetRandomSampler = torch.utils.data.sampler.SubsetRandomSampler

dataset = torchvision.datasets.ImageFolder(root= data_dir, transform=transform_train)

train_samples = SubsetRandomSampler(train_indices)
val_samples = SubsetRandomSampler(val_indices)
test_samples = SubsetRandomSampler(test_indices)

train_data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False,num_workers=1, sampler= train_samples)
validation_data_loader = torch.utils.data.DataLoader(dataset, batch_size=validation_batch_size, shuffle=False, sampler=val_samples)

dataset = torchvision.datasets.ImageFolder(root= data_dir, transform=transform_test)
test_data_loader = torch.utils.data.DataLoader(dataset, batch_size=test_batch_size, shuffle=False, sampler=test_samples)

Some of the training images

# functions to show an image
fig = plt.figure(figsize=(10, 15))
def imshow(img):
    img = img / 2 + 0.5     # denormalize change this
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))


# get some random training images
dataiter = iter(train_data_loader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s, ' % classes[labels[j]] for j in range(len(labels))))

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

actinic keratoses,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  melanoma,  melanocytic nevi,  melanocytic nevi,  basal cell carcinoma,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  basal cell carcinoma,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  basal cell carcinoma,  melanocytic nevi,  benign keratosis-like lesions,  melanocytic nevi,  benign keratosis-like lesions,  melanoma,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  actinic keratoses,  melanocytic nevi,  melanocytic nevi,  melanoma,  melanocytic nevi,  melanocytic nevi,  melanocytic nevi,  dermatofibroma,  melanocytic nevi,  melanocytic nevi,  melanoma,  melanocytic nevi,  melanocytic nevi,  basal cell carcinoma,  melanocytic nevi,  melanocytic nevi,  dermatofibroma,  basal cell carcinoma,  melanocytic nevi,  basal cell carcinoma,  melanocytic nevi, 

Downloading ResNet50

num_classes = len(classes)
net = torchvision.models.resnet18(pretrained = True)

# Replacing last layer of resnet to match number of classes which is 7
net.fc = nn.Linear(512, num_classes)
net = net.to(device)

Defining a Loss function and Optimizer

Classification Cross-Entropy loss equation:

$H_{y'} (y) := - \sum_{i} y_{i}' \log (y_i)$

The most common and effective Optimizer currently used is Adam: Adaptive Moments. You can look here for more information.

class_weights = class_weights.to(device)
criterion = nn.CrossEntropyLoss(weight = class_weights)
optimizer = optim.Adam(net.parameters(), lr=1e-5)
print(net)

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=7, bias=True)
)

Helper functions to evaluate the training process

from sklearn.metrics import accuracy_score

def get_accuracy(predicted, labels):
    batch_len, correct= 0, 0
    batch_len = labels.size(0)
    correct = (predicted == labels).sum().item()
    return batch_len, correct

def evaluate(model, val_loader):
    losses= 0
    num_samples_total=0
    correct_total=0
    model.eval()
    for inputs, labels in val_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        out = model(inputs)
        _, predicted = torch.max(out, 1)
        loss = criterion(out, labels)
        losses += loss.item() 
        b_len, corr = get_accuracy(predicted, labels)
        num_samples_total +=b_len
        correct_total +=corr
    accuracy = correct_total/num_samples_total
    losses = losses/len(val_loader)
    return losses, accuracy

Training the network

# number of loops over the dataset
num_epochs = 40
accuracy = []
val_accuracy = []
losses = []
val_losses = []


for epoch in range(num_epochs):
    running_loss = 0.0
    correct_total= 0.0
    num_samples_total=0.0
    for i, data in enumerate(train_data_loader):
        # get the inputs
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        # set the parameter gradients to zero
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        #compute accuracy
        _, predicted = torch.max(outputs, 1)
        b_len, corr = get_accuracy(predicted, labels)
        num_samples_total +=b_len
        correct_total +=corr
        running_loss += loss.item()

    
    running_loss /= len(train_data_loader)
    train_accuracy = correct_total/num_samples_total
    val_loss, val_acc = evaluate(net, validation_data_loader)
    
    print('Epoch: %d' %(epoch+1))
    print('Loss: %.3f  Accuracy:%.3f' %(running_loss, train_accuracy))
    print('Validation Loss: %.3f  Val Accuracy: %.3f' %(val_loss, val_acc))

    losses.append(running_loss)
    val_losses.append(val_loss)
    accuracy.append(train_accuracy)
    val_accuracy.append(val_acc)
print('Finished Training')

Epoch: 1
Loss: 1.759  Accuracy:0.426
Validation Loss: 1.489  Val Accuracy: 0.528
Epoch: 2
Loss: 1.168  Accuracy:0.623
Validation Loss: 1.005  Val Accuracy: 0.626
Epoch: 3
Loss: 0.891  Accuracy:0.671
Validation Loss: 1.019  Val Accuracy: 0.655
Epoch: 4
Loss: 0.775  Accuracy:0.699
Validation Loss: 0.851  Val Accuracy: 0.675
Epoch: 5
Loss: 0.705  Accuracy:0.720
Validation Loss: 0.773  Val Accuracy: 0.674
Epoch: 6
Loss: 0.644  Accuracy:0.730
Validation Loss: 0.879  Val Accuracy: 0.740
Epoch: 7
Loss: 0.622  Accuracy:0.737
Validation Loss: 0.871  Val Accuracy: 0.709
Epoch: 8
Loss: 0.572  Accuracy:0.755
Validation Loss: 0.779  Val Accuracy: 0.722
Epoch: 9
Loss: 0.553  Accuracy:0.757
Validation Loss: 0.756  Val Accuracy: 0.738
Epoch: 10
Loss: 0.511  Accuracy:0.770
Validation Loss: 0.790  Val Accuracy: 0.727
Epoch: 11
Loss: 0.496  Accuracy:0.774
Validation Loss: 0.757  Val Accuracy: 0.763
Epoch: 12
Loss: 0.450  Accuracy:0.791
Validation Loss: 0.746  Val Accuracy: 0.757
Epoch: 13
Loss: 0.425  Accuracy:0.794
Validation Loss: 0.753  Val Accuracy: 0.763
Epoch: 14
Loss: 0.387  Accuracy:0.804
Validation Loss: 0.660  Val Accuracy: 0.754
Epoch: 15
Loss: 0.375  Accuracy:0.808
Validation Loss: 0.760  Val Accuracy: 0.762
Epoch: 16
Loss: 0.372  Accuracy:0.812
Validation Loss: 0.741  Val Accuracy: 0.782
Epoch: 17
Loss: 0.355  Accuracy:0.819
Validation Loss: 0.808  Val Accuracy: 0.785
Epoch: 18
Loss: 0.322  Accuracy:0.829
Validation Loss: 0.746  Val Accuracy: 0.762
Epoch: 19
Loss: 0.312  Accuracy:0.837
Validation Loss: 0.761  Val Accuracy: 0.793
Epoch: 20
Loss: 0.306  Accuracy:0.831
Validation Loss: 0.857  Val Accuracy: 0.752
Epoch: 21
Loss: 0.291  Accuracy:0.836
Validation Loss: 0.745  Val Accuracy: 0.749
Epoch: 22
Loss: 0.273  Accuracy:0.843
Validation Loss: 0.770  Val Accuracy: 0.767
Epoch: 23
Loss: 0.296  Accuracy:0.835
Validation Loss: 0.786  Val Accuracy: 0.808
Epoch: 24
Loss: 0.260  Accuracy:0.857
Validation Loss: 0.822  Val Accuracy: 0.721
Epoch: 25
Loss: 0.252  Accuracy:0.856
Validation Loss: 0.824  Val Accuracy: 0.782
Epoch: 26
Loss: 0.245  Accuracy:0.853
Validation Loss: 0.822  Val Accuracy: 0.770
Epoch: 27
Loss: 0.226  Accuracy:0.865
Validation Loss: 0.752  Val Accuracy: 0.802
Epoch: 28
Loss: 0.241  Accuracy:0.863
Validation Loss: 0.862  Val Accuracy: 0.793
Epoch: 29
Loss: 0.206  Accuracy:0.869
Validation Loss: 0.984  Val Accuracy: 0.789
Epoch: 30
Loss: 0.167  Accuracy:0.890
Validation Loss: 0.869  Val Accuracy: 0.807
Epoch: 31
Loss: 0.188  Accuracy:0.878
Validation Loss: 0.882  Val Accuracy: 0.783
Epoch: 32
Loss: 0.181  Accuracy:0.890
Validation Loss: 0.836  Val Accuracy: 0.824
Epoch: 33
Loss: 0.178  Accuracy:0.883
Validation Loss: 0.972  Val Accuracy: 0.807
Epoch: 34
Loss: 0.202  Accuracy:0.875
Validation Loss: 0.801  Val Accuracy: 0.814
Epoch: 35
Loss: 0.164  Accuracy:0.897
Validation Loss: 0.858  Val Accuracy: 0.826
Epoch: 36
Loss: 0.166  Accuracy:0.897
Validation Loss: 0.830  Val Accuracy: 0.791
Epoch: 37
Loss: 0.155  Accuracy:0.901
Validation Loss: 0.830  Val Accuracy: 0.800
Epoch: 38
Loss: 0.143  Accuracy:0.900
Validation Loss: 0.934  Val Accuracy: 0.784
Epoch: 39
Loss: 0.172  Accuracy:0.895
Validation Loss: 0.858  Val Accuracy: 0.800
Epoch: 40
Loss: 0.131  Accuracy:0.910
Validation Loss: 0.796  Val Accuracy: 0.812
Finished Training

Plotting the training and validation loss curves.

epoch = range(1, num_epochs+1)
fig = plt.figure(figsize=(10, 15))
plt.subplot(2,1,2)
plt.plot(epoch, losses, label='Training loss')
plt.plot(epoch, val_losses, label='Validation loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epochs')
plt.legend()
plt.figure()
plt.show()

fig = plt.figure(figsize=(10, 15))
plt.subplot(2,1,2)
plt.plot(epoch, accuracy, label='Training accuracy')
plt.plot(epoch, val_accuracy, label='Validation accuracy')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epochs')
plt.legend()
plt.figure()
plt.show()

<Figure size 432x288 with 0 Axes>

<Figure size 432x288 with 0 Axes>

Test the network on the test data

We have trained the network over the training dataset. But we need to check if the network has learnt anything at all.

We will check this by predicting the class label that the neural network outputs, and checking it against the ground-truth. If the prediction is correct, we add the sample to the list of correct predictions.

Okay, first step. Let us display an image from the test set to get familiar.

fig = plt.figure(figsize=(10, 15))
dataiter = iter(test_data_loader)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s,  ' % classes[labels[j]] for j in range(len(labels))))

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

GroundTruth:  benign keratosis-like lesions,   melanocytic nevi,   melanocytic nevi,   benign keratosis-like lesions,   melanocytic nevi,   actinic keratoses,   melanocytic nevi,   melanocytic nevi,   melanocytic nevi,   benign keratosis-like lesions,  

Okay, now let us check the performance on the test network:

correct = 0
total = 0
net.eval()
with torch.no_grad():
    for data in test_data_loader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the test images: %d %%' % (
    100 * correct / total))

Accuracy of the network on the test images: 81 %

class_correct = list(0. for i in range(len(classes)))
class_total = list(1e-7 for i in range(len(classes)))
with torch.no_grad():
    for data in test_data_loader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(3):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1

for i in range(len(classes)):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

Accuracy of actinic keratoses : 64 %
Accuracy of basal cell carcinoma : 86 %
Accuracy of benign keratosis-like lesions : 70 %
Accuracy of dermatofibroma : 74 %
Accuracy of melanoma : 69 %
Accuracy of melanocytic nevi : 86 %
Accuracy of vascular lesions : 88 %

class_correct = list(0. for i in range(len(classes)))
class_total = list(1e-7 for i in range(len(classes)))
net.eval()
with torch.no_grad():
    for data in validation_data_loader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(3):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1

for i in range(len(classes)):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

Accuracy of actinic keratoses : 76 %
Accuracy of basal cell carcinoma : 82 %
Accuracy of benign keratosis-like lesions : 81 %
Accuracy of dermatofibroma : 16 %
Accuracy of melanoma : 58 %
Accuracy of melanocytic nevi : 86 %
Accuracy of vascular lesions : 74 %

Confusion Matrix

confusion_matrix = torch.zeros(len(classes), len(classes))
with torch.no_grad():
    for data in test_data_loader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        for t, p in zip(labels.view(-1), predicted.view(-1)):
                confusion_matrix[t.long(), p.long()] += 1

print(confusion_matrix)
cm = confusion_matrix.numpy()

tensor([[4.6000e+01, 1.0000e+01, 6.0000e+00, 0.0000e+00, 2.0000e+00, 1.0000e+00,
         0.0000e+00],
        [4.0000e+00, 8.7000e+01, 6.0000e+00, 0.0000e+00, 1.0000e+00, 3.0000e+00,
         2.0000e+00],
        [7.0000e+00, 1.6000e+01, 1.5100e+02, 4.0000e+00, 2.3000e+01, 1.9000e+01,
         0.0000e+00],
        [1.0000e+00, 4.0000e+00, 1.0000e+00, 1.7000e+01, 0.0000e+00, 0.0000e+00,
         0.0000e+00],
        [1.1000e+01, 5.0000e+00, 1.7000e+01, 2.0000e+00, 1.4800e+02, 3.9000e+01,
         1.0000e+00],
        [7.0000e+00, 3.2000e+01, 4.7000e+01, 1.2000e+01, 7.2000e+01, 1.1660e+03,
         5.0000e+00],
        [0.0000e+00, 2.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 3.0000e+00,
         2.3000e+01]])

fig,ax= plt.subplots(figsize=(7,7))
sns.heatmap(cm / (cm.astype(np.float).sum(axis=1) + 1e-9), annot=False, ax=ax)

# labels, title and ticks
ax.set_xlabel('Predicted', size=25);
ax.set_ylabel('True', size=25); 
ax.set_title('Confusion Matrix', size=25); 
ax.xaxis.set_ticklabels(['akiec','bcc','bkl','df', 'mel', 'nv','vasc'], size=15); \
ax.yaxis.set_ticklabels(['akiec','bcc','bkl','df','mel','nv','vasc'], size=15);

Grad cam

from collections import OrderedDict, Sequence

class _BaseWrapper(object):
    """
    Please modify forward() and backward() according to your task.
    """

    def __init__(self, model):
        super(_BaseWrapper, self).__init__()
        self.device = next(model.parameters()).device
        self.model = model
        self.handlers = []  # a set of hook function handlers

    def _encode_one_hot(self, ids):
        one_hot = torch.zeros_like(self.logits).to(self.device)
        one_hot.scatter_(1, ids, 1.0)
        return one_hot

    def forward(self, image):
        """
        Simple classification
        """
        self.model.zero_grad()
        self.logits = self.model(image)
        self.probs = F.softmax(self.logits, dim=1)
        return self.probs.sort(dim=1, descending=True)

    def backward(self, ids):
        """
        Class-specific backpropagation
        Either way works:
        1. self.logits.backward(gradient=one_hot, retain_graph=True)
        2. (self.logits * one_hot).sum().backward(retain_graph=True)
        """

        one_hot = self._encode_one_hot(ids)
        self.logits.backward(gradient=one_hot, retain_graph=True)

    def generate(self):
        raise NotImplementedError

    def remove_hook(self):
        """
        Remove all the forward/backward hook functions
        """
        for handle in self.handlers:
            handle.remove()


class GradCAM(_BaseWrapper):
    """
    "Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization"
    https://arxiv.org/pdf/1610.02391.pdf
    Look at Figure 2 on page 4
    """

    def __init__(self, model, candidate_layers=None):
        super(GradCAM, self).__init__(model)
        self.fmap_pool = OrderedDict()
        self.grad_pool = OrderedDict()
        self.candidate_layers = candidate_layers  # list

        def forward_hook(key):
            def forward_hook_(module, input, output):
                # Save featuremaps
                self.fmap_pool[key] = output.detach()

            return forward_hook_

        def backward_hook(key):
            def backward_hook_(module, grad_in, grad_out):
                # Save the gradients correspond to the featuremaps
                self.grad_pool[key] = grad_out[0].detach()

            return backward_hook_

        # If any candidates are not specified, the hook is registered to all the layers.
        for name, module in self.model.named_modules():
            if self.candidate_layers is None or name in self.candidate_layers:
                self.handlers.append(module.register_forward_hook(forward_hook(name)))
                self.handlers.append(module.register_backward_hook(backward_hook(name)))

    def _find(self, pool, target_layer):
        if target_layer in pool.keys():
            return pool[target_layer]
        else:
            raise ValueError("Invalid layer name: {}".format(target_layer))

    def _compute_grad_weights(self, grads):
        return F.adaptive_avg_pool2d(grads, 1)

    def forward(self, image):
        self.image_shape = image.shape[2:]
        return super(GradCAM, self).forward(image)

    def generate(self, target_layer):
        fmaps = self._find(self.fmap_pool, target_layer)
        grads = self._find(self.grad_pool, target_layer)
        weights = self._compute_grad_weights(grads)

        gcam = torch.mul(fmaps, weights).sum(dim=1, keepdim=True)
        gcam = F.relu(gcam)

        gcam = F.interpolate(
            gcam, self.image_shape, mode="bilinear", align_corners=False
        )

        B, C, H, W = gcam.shape
        gcam = gcam.view(B, -1)
        gcam -= gcam.min(dim=1, keepdim=True)[0]
        gcam /= gcam.max(dim=1, keepdim=True)[0]
        gcam = gcam.view(B, C, H, W)

        return gcam

def demo2(image, label, model):
    """
    Generate Grad-CAM
    """
    # Model
    model = model
    model.to(device)
    model.eval()

    # The layers
    target_layers = ["layer4"]
    target_class = label

    # Images
    images = image.unsqueeze(0)
    gcam = GradCAM(model=model)
    probs, ids = gcam.forward(images)
    ids_ = torch.LongTensor([[target_class]] * len(images)).to(device)
    gcam.backward(ids=ids_)

    for target_layer in target_layers:
        print("Generating Grad-CAM @{}".format(target_layer))

        # Grad-CAM
        regions = gcam.generate(target_layer=target_layer)
        for j in range(len(images)):
            print(
                "\t#{}: {} ({:.5f})".format(
                    j, classes[target_class], float(probs[ids == target_class])
                )
            )
            
            gcam=regions[j, 0]
            plt.imshow(gcam.cpu())
            plt.show()
            
image, label = next(iter(test_data_loader))
# Load the model
model = net
# Grad cam
demo2(image[0].to(device), label[0].to(device), model)


image = np.transpose(image[0], (1,2,0))
image2  = np.add(np.multiply(image.numpy(), np.array(norm_std)) ,np.array(norm_mean))
print("True Class: ", classes[label[0].cpu()])
plt.imshow(image)
plt.show()
plt.imshow(image2)
plt.show()

Generating Grad-CAM @layer4
	#0: melanocytic nevi (0.61514)

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

True Class:  melanocytic nevi

Saving the model

After training the model is saved

# torch.save(net.state_dict(), "./finalModelResNet18_dict.pth")

# Use the one below
# torch.save(model, "./finalModelFullResNet18_full.pth")

fullLoadedModel = torch.load("./finalModelResNet18_dict.pth")
fullLoadedModel.eval()

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-32-275ab0be82fe> in <module>
      5 
      6 fullLoadedModel = torch.load("./finalModelResNet18_dict.pth")
----> 7 fullLoadedModel.eval()

AttributeError: 'collections.OrderedDict' object has no attribute 'eval'

model_TEST = torchvision.models.resnet18(pretrained = True)
model_TEST.fc = nn.Linear(512, num_classes)
model_TEST = model_TEST.to(device)

loadModelDict = torch.load("./finalModelResNet18_dict.pth")
model_TEST.load_state_dict(loadModelDict)
model_TEST.eval()

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=7, bias=True)
)

print(classes)
class_correct = list(0. for i in range(len(classes)))
class_total = list(1e-7 for i in range(len(classes)))

maxIterations = 1000000000000000
currentIter = 0
with torch.no_grad():
    for data in test_data_loader:
        images, labels = data
        
#         print(images[0], labels[0])
#         arr_ = np.squeeze(images[0].numpy()[0]) # you can give axis attribute if you wanna squeeze in specific dimension
#         plt.imshow(arr_)
#         plt.show()
#         print(arr_.shape)
#         print(labels[0].numpy())
        
        images, labels = images.to(device), labels.to(device)
        
#         print(images.shape)
        
        outputs = model_TEST(images)
        _, predicted = torch.max(outputs, 1)
#         print("OUTPUTS", outputs)
        c = (predicted == labels).squeeze()
        for i in range(3):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1
        
        currentIter += 1
        if (currentIter >= maxIterations):
            break

for i in range(len(classes)):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

['actinic keratoses', 'basal cell carcinoma', 'benign keratosis-like lesions', 'dermatofibroma', 'melanoma', 'melanocytic nevi', 'vascular lesions']
Accuracy of actinic keratoses : 78 %
Accuracy of basal cell carcinoma : 79 %
Accuracy of benign keratosis-like lesions : 68 %
Accuracy of dermatofibroma : 69 %
Accuracy of melanoma : 74 %
Accuracy of melanocytic nevi : 86 %
Accuracy of vascular lesions : 99 %

# # import torch 
# # from torch.autograd import Variable 
# import torchvision.transforms.functional as TF
# from PIL import Image

# class_correct = list(0. for i in range(len(classes)))
# class_total = list(1e-7 for i in range(len(classes)))

# imsize_TEST = 224
# loader_TEST = transforms.Compose([transforms.Scale(imsize_TEST), transforms.ToTensor()])

# def image_loader_TEST(image_name):
#     """load image, returns cuda tensor"""
#     image = Image.open(image_name)
#     image = loader_TEST(image).float()
#     image = Variable(image, requires_grad=True)
#     image = image.unsqueeze(0)  #this is for VGG, may not be needed for ResNet
#     return image  #assumes that you're using GPU

# def image_loader2_TEST(imagePath):
#     image = Image.open(imagePath)
#     x = TF.to_tensor(image)
#     x.unsqueeze_(0)
    
# basePath_TEST = "C:/Users/marty/Desktop/FYP_Test/HAM10000 pt 2/SLClassificationAnEducationalCode-MEC2019/data/HAM10K/"
# # image = image_loader_TEST(basePath_TEST + "nv/ISIC_0024306.jpg")
# # image2 = image_loader_TEST(basePath_TEST + "akiec/ISIC_0024329.jpg")
# # image3 = image_loader_TEST(basePath_TEST + "df/ISIC_0024318.jpg")
# # image4 = image_loader_TEST(basePath_TEST + "mel/ISIC_0024310.jpg")
# # image5 = image_loader_TEST(basePath_TEST + "vasc/ISIC_0026876.jpg")

# image = basePath_TEST + "nv/ISIC_0024306.jpg"
# image2 = basePath_TEST + "akiec/ISIC_0024329.jpg"
# image3 = basePath_TEST + "df/ISIC_0024318.jpg"
# image4 = basePath_TEST + "mel/ISIC_0024310.jpg"
# image5 = basePath_TEST + "vasc/ISIC_0026876.jpg"

# imagePaths = [image, image2, image3, image4, image5]

# chosenImg = image2

# for imagePath in imagePaths:
#     x = image_loader_TEST(imagePath)
#     print(x.shape)

#     output_TEST = net(x)
#     _, predicted = torch.max(outputs, 1)
#     c = (predicted == labels).squeeze()

#     print(output_TEST)
    
# # arr_ = np.squeeze(chosenImg.numpy()[0]) # you can give axis attribute if you wanna squeeze in specific dimension
# # plt.imshow(image)
# # plt.show()
# # print(arr_.shape)

torch.Size([1, 3, 224, 298])
tensor([[-0.1498, -0.3748,  0.1886,  0.2736,  0.2813,  0.7390, -0.2782]],
       grad_fn=<AddmmBackward>)
torch.Size([1, 3, 224, 298])
tensor([[-0.1686, -0.3310,  0.1341,  0.3069,  0.2488,  0.7041, -0.2617]],
       grad_fn=<AddmmBackward>)
torch.Size([1, 3, 224, 298])
tensor([[-0.1818, -0.3600,  0.2335,  0.3087,  0.2619,  0.7035, -0.3375]],
       grad_fn=<AddmmBackward>)
torch.Size([1, 3, 224, 298])
tensor([[-0.1875, -0.3131,  0.1889,  0.2794,  0.2809,  0.6935, -0.2679]],
       grad_fn=<AddmmBackward>)
torch.Size([1, 3, 224, 298])
tensor([[-0.1956, -0.3668,  0.1750,  0.3072,  0.3039,  0.7206, -0.2588]],
       grad_fn=<AddmmBackward>)